home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / front.lha / front / m2c / Errors.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  16KB  |  614 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_IO
  4. #include "IO.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Listing
  8. #include "Listing.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Memory
  12. #include "Memory.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Sets
  16. #include "Sets.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Strings
  20. #include "Strings.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_StringMem
  24. #include "StringMem.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Idents
  28. #include "Idents.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_SysError
  32. #include "SysError.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_System
  36. #include "System.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_TokenTab
  40. #include "TokenTab.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Positions
  44. #include "Positions.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Strings
  48. #include "Strings.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_Errors
  52. #include "Errors.h"
  53. #endif
  54.  
  55. struct Errors_1 Errors_ErrorCount;
  56. BITSET Errors_ReportClass;
  57. struct Errors_2 Errors_ErrorTable;
  58.  
  59. #define eNone    0
  60. #define cTab    '\t'
  61. #define NoStringRef    -1
  62. #define MaxCode    160
  63. #define eWrongClass    16
  64. #define eWrongCode    17
  65. static BOOLEAN NoReports;
  66. static Errors_tReportMode ReportMode;
  67. static struct S_1 {
  68.     StringMem_tStringRef A[Errors_MaxErrorClass + 1];
  69. } ErrorClassRef;
  70. static struct S_2 {
  71.     StringMem_tStringRef A[MaxCode + 1];
  72. } ErrorCodeRef;
  73. static struct S_3 {
  74.     StringMem_tStringRef A[Errors_MaxErrorClass + 1];
  75. } ErrorCountRef;
  76. static CARDINAL i;
  77. static void WriteErrorMessage ARGS((CARDINAL ErrorCode, CARDINAL ErrorClass, CARDINAL Line, CARDINAL Column));
  78. static void KeepInfo ARGS((CARDINAL InfoClass, ADDRESS *Info));
  79. struct S_4 {
  80.     CHAR A[255 + 1];
  81. };
  82. static void WriteInfo ARGS((CARDINAL InfoClass, ADDRESS Info));
  83. struct S_5 {
  84.     CHAR A[255 + 1];
  85. };
  86. static void WriteTermSet ARGS((IO_tFile f, Sets_tSet s));
  87. static void SplitLine ARGS((Strings_tString C_1_line, CARDINAL *i, Strings_tString *s1));
  88. static void Finish ARGS(());
  89.  
  90.  
  91. void Errors_ErrorMessage
  92. # ifdef __STDC__
  93. (CARDINAL ErrorCode, CARDINAL ErrorClass, Positions_tPosition Position)
  94. # else
  95. (ErrorCode, ErrorClass, Position)
  96. CARDINAL ErrorCode, ErrorClass;
  97. Positions_tPosition Position;
  98. # endif
  99. {
  100.   Errors_ErrorMessageI(ErrorCode, ErrorClass, Position, (LONGCARD)eNone, (ADDRESS)NIL);
  101. }
  102.  
  103. void Errors_ErrorMessageI
  104. # ifdef __STDC__
  105. (CARDINAL ErrorCode, CARDINAL ErrorClass, Positions_tPosition Position, CARDINAL InfoClass, ADDRESS Info)
  106. # else
  107. (ErrorCode, ErrorClass, Position, InfoClass, Info)
  108. CARDINAL ErrorCode, ErrorClass;
  109. Positions_tPosition Position;
  110. CARDINAL InfoClass;
  111. ADDRESS Info;
  112. # endif
  113. {
  114.   INC(Errors_ErrorCount.A[ErrorClass]);
  115.   if (IN(ErrorClass, Errors_ReportClass)) {
  116.     NoReports = FALSE;
  117.     if (ReportMode == Errors_eImmediate) {
  118.       WriteErrorMessage(ErrorCode, ErrorClass, (LONGCARD)Position.Line, (LONGCARD)Position.Column);
  119.       WriteInfo(InfoClass, Info);
  120.       IO_WriteNl((System_tFile)IO_StdError);
  121.     } else {
  122.       KeepInfo(InfoClass, &Info);
  123.       Listing_PutError(ErrorCode, ErrorClass, (LONGCARD)Position.Line, (LONGCARD)Position.Column, InfoClass, Info);
  124.     }
  125.   }
  126.   if (ErrorClass < 3) {
  127.     Finish();
  128.   }
  129. }
  130.  
  131. void Errors_SetReportMode
  132. # ifdef __STDC__
  133. (Errors_tReportMode mode)
  134. # else
  135. (mode)
  136. Errors_tReportMode mode;
  137. # endif
  138. {
  139.   ReportMode = mode;
  140.   switch (ReportMode) {
  141.   case Errors_eListing:;
  142.     Listing_ListMode = Listing_Listing;
  143.     break;
  144.   default :
  145.     Listing_ListMode = Listing_NoListing;
  146.     break;
  147.   }
  148. }
  149.  
  150. void Errors_BeginErrors
  151. # ifdef __STDC__
  152. ()
  153. # else
  154. ()
  155. # endif
  156. {
  157.   CARDINAL i;
  158.   IO_tFile f;
  159.   Strings_tString s;
  160.   Strings_tString C_2_line;
  161.  
  162.   f = IO_ReadOpen(Errors_ErrorTable.A, 256L);
  163.   if (SysError_StatIsBad(f)) {
  164.     IO_WriteS((System_tFile)IO_StdError, (STRING)"Fatal error: cannot open ", 25L);
  165.     IO_WriteS((System_tFile)IO_StdError, Errors_ErrorTable.A, 256L);
  166.     IO_WriteNl((System_tFile)IO_StdError);
  167.     return;
  168.   }
  169.   for (;;) {
  170.     if (IO_EndOfFile(f)) {
  171.       goto EXIT_1;
  172.     }
  173.     Strings_ReadL(f, &C_2_line);
  174.     if (Strings_Char(&C_2_line, 1) == '$') {
  175.       goto EXIT_1;
  176.     }
  177.     if (Strings_Char(&C_2_line, 1) != '%') {
  178.       SplitLine(C_2_line, &i, &s);
  179.       if (i < 0 || i > Errors_MaxErrorClass) {
  180.         Errors_ErrorMessageI((LONGCARD)eWrongClass, (LONGCARD)Errors_eError, Positions_NoPosition, (LONGCARD)Errors_eString, ADR(C_2_line));
  181.       } else {
  182.         ErrorClassRef.A[i] = StringMem_PutString(&s);
  183.       }
  184.     }
  185.   } EXIT_1:;
  186.   for (;;) {
  187.     if (IO_EndOfFile(f)) {
  188.       goto EXIT_2;
  189.     }
  190.     Strings_ReadL(f, &C_2_line);
  191.     if (Strings_Char(&C_2_line, 1) == '$') {
  192.       goto EXIT_2;
  193.     }
  194.     if (Strings_Char(&C_2_line, 1) != '%') {
  195.       SplitLine(C_2_line, &i, &s);
  196.       if (i < 0 || i > MaxCode) {
  197.         Errors_ErrorMessageI((LONGCARD)eWrongCode, (LONGCARD)Errors_eError, Positions_NoPosition, (LONGCARD)Errors_eString, ADR(C_2_line));
  198.       } else {
  199.         ErrorCodeRef.A[i] = StringMem_PutString(&s);
  200.       }
  201.     }
  202.   } EXIT_2:;
  203.   for (;;) {
  204.     if (IO_EndOfFile(f)) {
  205.       goto EXIT_3;
  206.     }
  207.     Strings_ReadL(f, &C_2_line);
  208.     if (Strings_Char(&C_2_line, 1) == '$') {
  209.       goto EXIT_3;
  210.     }
  211.     if (Strings_Char(&C_2_line, 1) != '%') {
  212.       SplitLine(C_2_line, &i, &s);
  213.       if (i < 0 || i > Errors_MaxErrorClass) {
  214.         Errors_ErrorMessageI((LONGCARD)eWrongClass, (LONGCARD)Errors_eError, Positions_NoPosition, (LONGCARD)Errors_eString, ADR(C_2_line));
  215.       } else {
  216.         ErrorCountRef.A[i] = StringMem_PutString(&s);
  217.       }
  218.     }
  219.   } EXIT_3:;
  220.   IO_ReadClose(f);
  221. }
  222.  
  223. void Errors_CloseErrors
  224. # ifdef __STDC__
  225. ()
  226. # else
  227. ()
  228. # endif
  229. {
  230.   CARDINAL i;
  231.   StringMem_tStringRef r;
  232.   CARDINAL ErrorCode, ErrorClass, Line, Column, InfoClass;
  233.   ADDRESS Info;
  234.  
  235.   if (NoReports) {
  236.     return;
  237.   }
  238.   while (Listing_HasError()) {
  239.     Listing_GetError(&ErrorCode, &ErrorClass, &Line, &Column, &InfoClass, &Info);
  240.     WriteErrorMessage(ErrorCode, ErrorClass, Line, Column);
  241.     WriteInfo(InfoClass, Info);
  242.     IO_WriteNl((System_tFile)IO_StdError);
  243.   }
  244.   for (i = 0; i <= Errors_MaxErrorClass; i += 1) {
  245.     if (Errors_ErrorCount.A[i] > 0) {
  246.       IO_WriteS((System_tFile)IO_StdError, (STRING)"  ", 2L);
  247.       IO_WriteI((System_tFile)IO_StdError, (LONGINT)Errors_ErrorCount.A[i], 1L);
  248.       IO_WriteC((System_tFile)IO_StdError, ' ');
  249.       r = ErrorCountRef.A[i];
  250.       if (r == NoStringRef) {
  251.         IO_WriteS((System_tFile)IO_StdError, (STRING)"in error class ", 15L);
  252.         IO_WriteI((System_tFile)IO_StdError, (LONGINT)i, 1L);
  253.       } else {
  254.         StringMem_WriteString((System_tFile)IO_StdError, r);
  255.       }
  256.     }
  257.   }
  258.   IO_WriteNl((System_tFile)IO_StdError);
  259. }
  260.  
  261. static void WriteErrorMessage
  262. # ifdef __STDC__
  263. (CARDINAL ErrorCode, CARDINAL ErrorClass, CARDINAL Line, CARDINAL Column)
  264. # else
  265. (ErrorCode, ErrorClass, Line, Column)
  266. CARDINAL ErrorCode, ErrorClass, Line, Column;
  267. # endif
  268. {
  269.   StringMem_tStringRef r;
  270.  
  271.   if (ReportMode != Errors_eListing && Line != 0) {
  272.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)Line, 3L);
  273.     IO_WriteS((System_tFile)IO_StdError, (STRING)", ", 2L);
  274.   }
  275.   if (Column != 0) {
  276.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)Column, 2L);
  277.     IO_WriteS((System_tFile)IO_StdError, (STRING)": ", 2L);
  278.   }
  279.   if (ErrorClass > Errors_MaxErrorClass || ErrorClass < 0) {
  280.     IO_WriteS((System_tFile)IO_StdError, (STRING)"Error class: ", 13L);
  281.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)ErrorClass, 1L);
  282.   } else {
  283.     r = ErrorClassRef.A[ErrorClass];
  284.     if (r == NoStringRef) {
  285.       IO_WriteS((System_tFile)IO_StdError, (STRING)"Error class: ", 13L);
  286.       IO_WriteI((System_tFile)IO_StdError, (LONGINT)ErrorClass, 1L);
  287.     } else {
  288.       StringMem_WriteString((System_tFile)IO_StdError, r);
  289.     }
  290.   }
  291.   if (ErrorCode > MaxCode || ErrorCode < 0) {
  292.     if (ErrorCode >= Errors_SysOffset) {
  293.       IO_WriteS((System_tFile)IO_StdError, (STRING)" system error code: ", 20L);
  294.       IO_WriteI((System_tFile)IO_StdError, (LONGINT)(ErrorCode - Errors_SysOffset), 1L);
  295.     } else {
  296.       IO_WriteS((System_tFile)IO_StdError, (STRING)" error code: ", 13L);
  297.       IO_WriteI((System_tFile)IO_StdError, (LONGINT)ErrorCode, 1L);
  298.     }
  299.   } else {
  300.     r = ErrorCodeRef.A[ErrorCode];
  301.     if (r == NoStringRef) {
  302.       if (ErrorCode >= Errors_SysOffset) {
  303.         IO_WriteS((System_tFile)IO_StdError, (STRING)" system error code: ", 20L);
  304.         IO_WriteI((System_tFile)IO_StdError, (LONGINT)(ErrorCode - Errors_SysOffset), 1L);
  305.       } else {
  306.         IO_WriteS((System_tFile)IO_StdError, (STRING)" error code: ", 13L);
  307.         IO_WriteI((System_tFile)IO_StdError, (LONGINT)ErrorCode, 1L);
  308.       }
  309.     } else {
  310.       StringMem_WriteString((System_tFile)IO_StdError, r);
  311.     }
  312.   }
  313. }
  314.  
  315. static void KeepInfo
  316. # ifdef __STDC__
  317. (CARDINAL InfoClass, ADDRESS *Info)
  318. # else
  319. (InfoClass, Info)
  320. CARDINAL InfoClass;
  321. ADDRESS *Info;
  322. # endif
  323. {
  324.   INTEGER *InfPtrToInteger, *PtrToInteger;
  325.   SHORTCARD *InfPtrToShort, *PtrToShort;
  326.   LONGINT *InfPtrToLong, *PtrToLong;
  327.   REAL *InfPtrToReal, *PtrToReal;
  328.   BOOLEAN *InfPtrToBoolean, *PtrToBoolean;
  329.   CHAR *InfPtrToCharacter, *PtrToCharacter;
  330.   Strings_tString *InfPtrToString, *PtrToString;
  331.   struct S_4 *InfPtrToArray, *PtrToArray;
  332.   Sets_tSet *InfPtrToSet, *PtrToSet;
  333.   Idents_tIdent *InfPtrToIdent, *PtrToIdent;
  334.  
  335.   if (InfoClass == eNone) {
  336.     return;
  337.   }
  338.   switch (InfoClass) {
  339.   case Errors_eInteger:;
  340.     InfPtrToInteger = (LONGINT *)Memory_Alloc((LONGINT)sizeof(INTEGER));
  341.     PtrToInteger = (LONGINT *)(*Info);
  342.     *InfPtrToInteger = *PtrToInteger;
  343.     *Info = (ADDRESS)InfPtrToInteger;
  344.     break;
  345.   case Errors_eShort:;
  346.     InfPtrToShort = (SHORTCARD *)Memory_Alloc((LONGINT)sizeof(SHORTCARD));
  347.     PtrToShort = (SHORTCARD *)(*Info);
  348.     *InfPtrToShort = *PtrToShort;
  349.     *Info = (ADDRESS)InfPtrToShort;
  350.     break;
  351.   case Errors_eLong:;
  352.     InfPtrToLong = (LONGINT *)Memory_Alloc((LONGINT)sizeof(LONGINT));
  353.     PtrToLong = (LONGINT *)(*Info);
  354.     *InfPtrToLong = *PtrToLong;
  355.     *Info = (ADDRESS)InfPtrToLong;
  356.     break;
  357.   case Errors_eReal:;
  358.     InfPtrToReal = (REAL *)Memory_Alloc((LONGINT)sizeof(REAL));
  359.     PtrToReal = (REAL *)(*Info);
  360.     *InfPtrToReal = *PtrToReal;
  361.     *Info = (ADDRESS)InfPtrToReal;
  362.     break;
  363.   case Errors_eBoolean:;
  364.     InfPtrToBoolean = (BOOLEAN *)Memory_Alloc((LONGINT)sizeof(BOOLEAN));
  365.     PtrToBoolean = (BOOLEAN *)(*Info);
  366.     *InfPtrToBoolean = *PtrToBoolean;
  367.     *Info = (ADDRESS)InfPtrToBoolean;
  368.     break;
  369.   case Errors_eCharacter:;
  370.     InfPtrToCharacter = (CHAR *)Memory_Alloc((LONGINT)sizeof(CHAR));
  371.     PtrToCharacter = (CHAR *)(*Info);
  372.     *InfPtrToCharacter = *PtrToCharacter;
  373.     *Info = (ADDRESS)InfPtrToCharacter;
  374.     break;
  375.   case Errors_eString:;
  376.     InfPtrToString = (Strings_tString *)Memory_Alloc((LONGINT)sizeof(Strings_tString));
  377.     PtrToString = (Strings_tString *)(*Info);
  378.     Strings_Assign(InfPtrToString, PtrToString);
  379.     *Info = (ADDRESS)InfPtrToString;
  380.     break;
  381.   case Errors_eArray:;
  382.     InfPtrToArray = (struct S_4 *)Memory_Alloc(256L);
  383.     PtrToArray = (struct S_4 *)(*Info);
  384.     *InfPtrToArray = *PtrToArray;
  385.     *Info = (ADDRESS)InfPtrToArray;
  386.     break;
  387.   case Errors_eIdent:;
  388.     InfPtrToIdent = (SHORTCARD *)Memory_Alloc((LONGINT)sizeof(Idents_tIdent));
  389.     PtrToIdent = (SHORTCARD *)(*Info);
  390.     *InfPtrToIdent = *PtrToIdent;
  391.     *Info = (ADDRESS)InfPtrToIdent;
  392.     break;
  393.   case Errors_eTermSet:;
  394.     InfPtrToSet = (Sets_tSet *)Memory_Alloc((LONGINT)sizeof(Sets_tSet));
  395.     PtrToSet = (Sets_tSet *)(*Info);
  396.     Sets_MakeSet(InfPtrToSet, (LONGCARD)PtrToSet->MaxElmt);
  397.     Sets_Assign(InfPtrToSet, *PtrToSet);
  398.     *Info = (ADDRESS)InfPtrToSet;
  399.     break;
  400.   default :
  401.     break;
  402.   }
  403. }
  404.  
  405. static void WriteInfo
  406. # ifdef __STDC__
  407. (CARDINAL InfoClass, ADDRESS Info)
  408. # else
  409. (InfoClass, Info)
  410. CARDINAL InfoClass;
  411. ADDRESS Info;
  412. # endif
  413. {
  414.   INTEGER *PtrToInteger;
  415.   SHORTCARD *PtrToShort;
  416.   LONGINT *PtrToLong;
  417.   REAL *PtrToReal;
  418.   BOOLEAN *PtrToBoolean;
  419.   CHAR *PtrToCharacter;
  420.   Strings_tString *PtrToString;
  421.   struct S_5 *PtrToArray;
  422.   Sets_tSet *PtrToSet;
  423.   Idents_tIdent *PtrToIdent;
  424.  
  425.   if (InfoClass == eNone) {
  426.     return;
  427.   }
  428.   IO_WriteC((System_tFile)IO_StdError, ' ');
  429.   switch (InfoClass) {
  430.   case Errors_eInteger:;
  431.     PtrToInteger = (LONGINT *)Info;
  432.     IO_WriteI((System_tFile)IO_StdError, *PtrToInteger, 1L);
  433.     break;
  434.   case Errors_eShort:;
  435.     PtrToShort = (SHORTCARD *)Info;
  436.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)(*PtrToShort), 1L);
  437.     break;
  438.   case Errors_eLong:;
  439.     PtrToLong = (LONGINT *)Info;
  440.     IO_WriteLong((System_tFile)IO_StdError, *PtrToLong, 1L);
  441.     break;
  442.   case Errors_eReal:;
  443.     PtrToReal = (REAL *)Info;
  444.     IO_WriteR((System_tFile)IO_StdError, *PtrToReal, 1L, 10L, 1L);
  445.     break;
  446.   case Errors_eBoolean:;
  447.     PtrToBoolean = (BOOLEAN *)Info;
  448.     IO_WriteB((System_tFile)IO_StdError, *PtrToBoolean);
  449.     break;
  450.   case Errors_eCharacter:;
  451.     PtrToCharacter = (CHAR *)Info;
  452.     IO_WriteC((System_tFile)IO_StdError, *PtrToCharacter);
  453.     break;
  454.   case Errors_eString:;
  455.     PtrToString = (Strings_tString *)Info;
  456.     Strings_WriteS((System_tFile)IO_StdError, PtrToString);
  457.     break;
  458.   case Errors_eArray:;
  459.     PtrToArray = (struct S_5 *)Info;
  460.     IO_WriteS((System_tFile)IO_StdError, (*PtrToArray).A, 256L);
  461.     break;
  462.   case Errors_eIdent:;
  463.     PtrToIdent = (SHORTCARD *)Info;
  464.     Idents_WriteIdent((System_tFile)IO_StdError, *PtrToIdent);
  465.     break;
  466.   case Errors_eTermSet:;
  467.     PtrToSet = (Sets_tSet *)Info;
  468.     WriteTermSet((System_tFile)IO_StdError, *PtrToSet);
  469.     break;
  470.   default :
  471.     IO_WriteS((System_tFile)IO_StdError, (STRING)"Info Class: ", 12L);
  472.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)InfoClass, 1L);
  473.     break;
  474.   }
  475. }
  476.  
  477. static void WriteTermSet
  478. # ifdef __STDC__
  479. (IO_tFile f, Sets_tSet s)
  480. # else
  481. (f, s)
  482. IO_tFile f;
  483. Sets_tSet s;
  484. # endif
  485. {
  486.   CARDINAL i;
  487.   TokenTab_TokenError Error;
  488.  
  489.   {
  490.     LONGCARD B_1 = 0, B_2 = TokenTab_MAXTerm;
  491.  
  492.     if (B_1 <= B_2)
  493.       for (i = B_1;; i += 1) {
  494.         if (Sets_IsElement(i, &s)) {
  495.           IO_WriteS(f, (STRING)" ", 1L);
  496.           Idents_WriteIdent(f, TokenTab_TokenToSymbol((TokenTab_Vocabulary)i, &Error));
  497.         }
  498.         if (i >= B_2) break;
  499.       }
  500.   }
  501. }
  502.  
  503. static void SplitLine
  504. # ifdef __STDC__
  505. (Strings_tString C_1_line, CARDINAL *i, Strings_tString *s1)
  506. # else
  507. (C_1_line, i, s1)
  508. Strings_tString C_1_line;
  509. CARDINAL *i;
  510. Strings_tString *s1;
  511. # endif
  512. {
  513.   CARDINAL m, p1, p2;
  514.   Strings_tString s;
  515.  
  516.   p1 = 1;
  517.   p2 = 1;
  518.   m = Strings_Length(&C_1_line);
  519.   for (;;) {
  520.     if (p2 > m) {
  521.       goto EXIT_4;
  522.     }
  523.     if (Strings_Char(&C_1_line, (Strings_tStringIndex)p2) == cTab) {
  524.       goto EXIT_4;
  525.     }
  526.     INC(p2);
  527.   } EXIT_4:;
  528.   DEC(p2);
  529.   if (p1 > p2) {
  530.     *i = 0;
  531.   } else {
  532.     Strings_SubString(&C_1_line, (Strings_tStringIndex)p1, (Strings_tStringIndex)p2, &s);
  533.     *i = Strings_StringToInt(&s);
  534.   }
  535.   p1 = p2 + 1;
  536.   for (;;) {
  537.     if (p1 > m) {
  538.       goto EXIT_5;
  539.     }
  540.     if (Strings_Char(&C_1_line, (Strings_tStringIndex)p1) != cTab) {
  541.       goto EXIT_5;
  542.     }
  543.     INC(p1);
  544.   } EXIT_5:;
  545.   p2 = p1;
  546.   for (;;) {
  547.     if (p2 > m) {
  548.       goto EXIT_6;
  549.     }
  550.     if (Strings_Char(&C_1_line, (Strings_tStringIndex)p2) == cTab) {
  551.       goto EXIT_6;
  552.     }
  553.     INC(p2);
  554.   } EXIT_6:;
  555.   DEC(p2);
  556.   if (p1 > p2) {
  557.     Strings_AssignEmpty(s1);
  558.   } else {
  559.     Strings_SubString(&C_1_line, (Strings_tStringIndex)p1, (Strings_tStringIndex)p2, s1);
  560.   }
  561. }
  562.  
  563. static void Finish
  564. # ifdef __STDC__
  565. ()
  566. # else
  567. ()
  568. # endif
  569. {
  570.   Errors_CloseErrors();
  571.   IO_CloseIO();
  572.   Exit(1L);
  573. }
  574.  
  575. void BEGIN_Errors()
  576. {
  577.   static BOOLEAN has_been_called = FALSE;
  578.  
  579.   if (!has_been_called) {
  580.     has_been_called = TRUE;
  581.  
  582.     BEGIN_Positions();
  583.     BEGIN_IO();
  584.     BEGIN_Listing();
  585.     BEGIN_Memory();
  586.     BEGIN_Sets();
  587.     BEGIN_Strings();
  588.     BEGIN_StringMem();
  589.     BEGIN_Idents();
  590.     BEGIN_SysError();
  591.     BEGIN_System();
  592.     BEGIN_TokenTab();
  593.     BEGIN_Positions();
  594.     BEGIN_Strings();
  595.  
  596.     NoReports = TRUE;
  597.     ReportMode = Errors_eNoListing;
  598.     (void)strncpy((char *)Errors_ErrorTable.A, "ErrorTab", sizeof(Errors_ErrorTable.A));
  599.     Errors_ReportClass = SET_cRNG(0, Errors_MaxErrorClass);
  600.     for (i = 0; i <= Errors_MaxErrorClass; i += 1) {
  601.       Errors_ErrorCount.A[i] = 0;
  602.     }
  603.     for (i = 0; i <= Errors_MaxErrorClass; i += 1) {
  604.       ErrorClassRef.A[i] = NoStringRef;
  605.     }
  606.     for (i = 0; i <= MaxCode; i += 1) {
  607.       ErrorCodeRef.A[i] = NoStringRef;
  608.     }
  609.     for (i = 0; i <= Errors_MaxErrorClass; i += 1) {
  610.       ErrorCountRef.A[i] = NoStringRef;
  611.     }
  612.   }
  613. }
  614.